.TH std::weak_ptr::lock 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::weak_ptr::lock \- std::weak_ptr::lock

.SH Synopsis
   std::shared_ptr<T> lock() const noexcept;  \fI(since C++11)\fP

   Creates a new std::shared_ptr that shares ownership of the managed object. If there
   is no managed object, i.e. *this is empty, then the returned shared_ptr also is
   empty.

   Effectively returns expired() ? shared_ptr<T>() : shared_ptr<T>(*this), executed
   atomically.

.SH Parameters

   \fI(none)\fP

.SH Return value

   A shared_ptr which shares ownership of the owned object if std::weak_ptr::expired
   returns false. Else returns default-constructed shared_ptr of type T.

.SH Notes

   Both this function and the constructor of std::shared_ptr may be used to acquire
   temporary ownership of the managed object referred to by a std::weak_ptr. The
   difference is that the constructor of std::shared_ptr throws an exception when its
   std::weak_ptr argument is empty, while std::weak_ptr<T>::lock() constructs an empty
   std::shared_ptr<T>.

.SH Example


// Run this code

 #include <iostream>
 #include <memory>

 void observe(std::weak_ptr<int> weak)
 {
     if (auto p = weak.lock())
         std::cout << "\\tobserve() is able to lock weak_ptr<>, value=" << *p << '\\n';
     else
         std::cout << "\\tobserve() is unable to lock weak_ptr<>\\n";
 }

 int main()
 {
     std::weak_ptr<int> weak;
     std::cout << "weak_ptr<> is not yet initialized\\n";
     observe(weak);

     {
         auto shared = std::make_shared<int>(42);
         weak = shared;
         std::cout << "weak_ptr<> is initialized with shared_ptr\\n";
         observe(weak);
     }

     std::cout << "shared_ptr<> has been destructed due to scope exit\\n";
     observe(weak);
 }

.SH Output:

 weak_ptr<> is not yet initialized
         observe() is unable to lock weak_ptr<>
 weak_ptr<> is initialized with shared_ptr
         observe() is able to lock weak_ptr<>, value=42
 shared_ptr<> has been destructed due to scope exit
         observe() is unable to lock weak_ptr<>

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

      DR    Applied to           Behavior as published              Correct behavior
                       lock() was not required to be atomic, but
   LWG 2316 C++11      required to be noexcept, which led to a   specified to be atomic
                       contradiction

.SH See also

   expired checks whether the referenced object was already deleted
           \fI(public member function)\fP
